var tool = window.tool;

/* @target 判断常用类型的值是否符合规则
 * @param type 类型
 * @param value 值
 * @return true 符合 / false 不符合
 */
tool.judge = function(type, value) {
	var flag = null;
	switch(type) {
		case "name": //姓名: 汉字开头,2~6位汉字或·
			//			flag = /^[\u4E00-\u9FA5][\u4E00-\u9FA5·]{1,5}$/.test(value);
			//姓名: 汉字和字母组成,1~10个字符以内
			flag = /^[0-9a-zA-Z\u4E00-\u9FA5]{1,10}$/.test(value);
			break;
		case "phone": //手机号: 1开头,11位数字
			flag = /^1[0-9]{10}$/.test(value);
			break;
		case "password": //用户密码: 8~20位
			flag = /^.{8,20}$/.test(value);
			break;
		case "integer": //正整数(不含0)
			flag = /^[1-9]\d*$/.test(value);
			break;
		case "integer0": //正整数(含0)
			flag = /^([1-9]\d*|0)$/.test(value);
			break;
		case "positiveFloat": //正浮点数(不含0)
			flag = /^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$/.test(value);
			break;
		case "classname": //班级名称
			flag = /^[a-zA-Z0-9-_|()|\u4e00-\u9fa5|（）]{1,20}$/.test(value);
			break;
			case "campusname": //校区名称
			flag = /^[a-zA-Z0-9-_|()|\u4e00-\u9fa5|（）]{1,30}$/.test(value);
			break;
		case "empty": //非空字符串
			flag = (value !== "");
			break;
		case "courseName": //课程名称
			flag = /^[a-zA-Z0-9-_|()|\u4e00-\u9fa5|（）]{1,50}$/.test(value);
			break;
		case "checkValue": //数字字母
			flag = /^[A-Za-z0-9]+$/.test(value);
			break;
	}
	return flag;
}

/* @target 检验表单字段是否符合规则
 * @param obj 表单数据对象 (表单元素必须带data-field属性才能非空检查)
 * @param rules 自定义规则数组 [{express:规则表达式,focus:不符合时焦点元素选择器,msg:不符合时提示信息}]
 * @return true 符合 / false 不符合
 */
tool.validate = function(rules, isCenter) {
	//自定义验证规则检查
	for(var i in rules) {
		var r = rules[i];
		//不符合规则
		if(!r.judge) {
			//获取焦点
			if(r.focus) {
				r.focus.focus();
			}
			//弹出提示
			if(r.tips) {
				let message = (isCenter? "message2": "message");
				tool[message]({
					showClose: true,
					type: 'warning',
					message: r.tips,
					duration: 4500
				});
			}
			return false;
		}
	}
	return true;
}

/* @target 加密字符串
 * @param str 明文
 * @return 密文
 */
tool.encode = function(str) {
	return window.btoa(unescape(encodeURIComponent(str)));
}

/* @target 解密字符串
 * @param str 密文明文
 * @return 明文
 */
tool.decode = function(str) {
	//密文有可能被破坏导致报异常
	try {
		return decodeURIComponent(escape(window.atob(str)));
	} catch(err) {
		return null;
	}
}

/* @target 加密后缓存数据
 * @param key 键
 * @param value 值
 * @param isJson 值是否对象
 */
tool.setItem = function(key, value, isJson) {
	//如果是json对象则转字符串
	value = (isJson ? JSON.stringify(value) : value);
	//键和值都加密
	key = tool.encode(key);
	value = tool.encode(value);
	//保存
	localStorage.setItem(key, value);
}

/* @target 读取缓存的加密数据
 * @param key 键
 * @param isJson 值是否对象
 * @return 值
 */
tool.getItem = function(key, isJson) {
	//加密键,获取值
	key = tool.encode(key);
	var value = tool.decode(localStorage.getItem(key));

	//如不为空且是json对象则转换
	if(value != null && isJson) {
		value = JSON.parse(value);
	}
	return value;
}

/* @target 删除缓存的加密数据
 * @param key 值
 */
tool.removeItem = function(key) {
	key = tool.encode(key);
	var value = localStorage.removeItem(key);
}

/* @target 复制对象
 * @param obj 被复制的对象
 * @return 新对象
 */
tool.clone = function(obj) {
	//日期格式
	if(obj instanceof Date) {
		return new Date(obj.valueOf());
	}
	//json格式
	return JSON.parse(JSON.stringify(obj));
}

/* @target 获取唯一编号uuid
 * @return uuid
 */
tool.uuid = function() {
	//7位 16进制随机数
	var random = (((1 + Math.random()) * 0x10000000) | 0).toString(16).substring(1);
	//13位 当前时间毫秒数
	var time = new Date().getTime();
	return time + random;
}

/* @target 将数据字典数组转对象
 * @param arry 数字字典数组
 * @return 数据字典对象
 */
tool.parseDict = function(arry) {
	var obj = {};
	arry.forEach(function(item) {
		obj[item.value] = item.name;
	});
	return obj;
}

/* @target 将字符串中的非数字剔除,转成数字类型
 * @param val 字符串
 * @return 数字
 */
tool.parseInt = function(val) {
	//整数,或者为null,直接返回
	if(typeof val == "number" || val == null) {
		return val;
	}
	//去除非数字,转数字类型
	val = parseInt(val.replace(/[^\d]/g, ''));
	return(isNaN(val) ? "" : val);
}

/* @target 转换对象中的属性值
 * @param value1 : 原本的值
 * @param value2 : 目标的值
 * @param obj : 待转换的对象
 * @param fields : 字符串数组,要转换的属性,如 ["a","b.b1"]
 */
tool.change = function(value1, value2, obj, fields) {
	fields.forEach(function(field) {
		//直接更改一级属性
		if(field.indexOf(".") < 0) {
			if(isEqual(obj[field])) {
				obj[field] = value2;
			}
			return;
		}
		var a = field.split(".")[0];
		var b = field.split(".")[1];
		var son = obj[a];
		//如果属性是数组
		if(son instanceof Array) {
			//遍历数组,更改数组元素的属性的值
			son.forEach(function(item) {
				if(isEqual(item[b])) {
					item[b] = value2;
				}
			})
		} else {
			//不是数组,默认是对象,属性的值
			if(isEqual(son[b])) {
				son[b] = value2;
			}
		}
	})
	function isEqual(val) {
		if(value1 instanceof RegExp) {
			return value1.test(val);
		} else {
			return value1 === val;
		}
	}
}


tool.fullScreen = function(element) {
	var el = element;
	var rfs = el.requestFullScreen || el.webkitRequestFullScreen || el.mozRequestFullScreen || el.msRequestFullScreen;
	//typeof rfs != "undefined" && rfs
	if(rfs) {
		rfs.call(el);
	} else if(typeof window.ActiveXObject !== "undefined") {
		//for IE，这里其实就是模拟了按下键盘的F11，使浏览器全屏
		var wscript = new ActiveXObject("WScript.Shell");
		if(wscript != null) {
			wscript.SendKeys("{F11}");
		}
	}
}

//退出全屏
tool.exitScreen = function() {
	var el = document;
	var cfs = el.cancelFullScreen || el.webkitCancelFullScreen || el.mozCancelFullScreen || el.exitFullScreen;
	//typeof cfs != "undefined" && cfs
	if(cfs) {
		cfs.call(el);
	} else if(typeof window.ActiveXObject !== "undefined") {
		//for IE，这里和fullScreen相同，模拟按下F11键退出全屏
		var wscript = new ActiveXObject("WScript.Shell");
		if(wscript != null) {
			wscript.SendKeys("{F11}");
		}
	}
}

/**
 * 获取数据字典的中文含义
 * @param value 数据字典值；value为-100则返回字典数组（对象）
 * @param k 数据字典键值名称
 * @param isarray true-返回数组；false-返回转换对象
 * @returns 中文含义/字典数组/字典对象
 */
tool.getDictNameByValue = function(value, k, isarray = true) {
	if(!window._g_dict_data1619) {
		window._g_dict_data1619 = JSON.parse(tool.getItem(window.lsKey.dict));
	}
	let data = window._g_dict_data1619[k];
	if(!data) return '';
	if(value == -100) {
		if(isarray)
			return data; //返回字典数组
		else {
			var obj = {};
			data.forEach(function(item) {
				obj[item.value] = item.name;
			});
			return obj; //返回字典对象
		}
	}
	for(let i = 0; i < data.length; i++) {
		if(data[i].value == value) {
			return data[i].name;
		}
	}
	return '';
}

/* @target 加密字符串
 * @param word 明文
 * @return 密文
 */
tool.encrypt = function (word) {
  //获取密钥
  let aesKey = tool.getItem(lsKey.token);
  if (aesKey != null && aesKey.length >= 32) {
	aesKey = aesKey.substring(aesKey.length - 32);
}
  let key = CryptoJS.enc.Utf8.parse(aesKey);
  //字符串转编码对象,加密
  word = CryptoJS.enc.Utf8.parse(word);
  let encrypt = CryptoJS.AES.encrypt(word, key, {
    mode: CryptoJS.mode.ECB,
    padding: CryptoJS.pad.Pkcs7
  });
  return encrypt.toString();
}

/* @target 解密字符串
 * @param word 明文
 * @return 密文
 */
tool.decrypt = function(word) {
	//获取密钥
	let aesKey = tool.getItem(lsKey.token);
	if (aesKey != null && aesKey.length >= 32) {
		aesKey = aesKey.substring(aesKey.length - 32);
	}
	let key = CryptoJS.enc.Utf8.parse(aesKey);
	//解密,编码对象转字符串
	let decrypt = CryptoJS.AES.decrypt(word, key, {
		mode: CryptoJS.mode.ECB,
		padding: CryptoJS.pad.Pkcs7
	});
	decrypt = CryptoJS.enc.Utf8.stringify(decrypt);
	return decrypt.toString();
}

/* @target 检测当前系统是否存在指定字体
 * @param font 指定字体
 * @return 是否存在 (在windows下检测微软雅黑无效)
 */
tool.checkFont = function(font) {
	//创建一个span元素加到body中
    var body = document.getElementsByTagName("body")[0];
	var span = document.createElement("span");
	body.appendChild(span);
	//设置span的字体和内容
	var word = "HelloWorld © 复杂的字符串のvtron Company";
	span.style.fontSize = '72px';
    span.style.fontFamily = word;
	span.innerHTML = word;
	//获取当前字体的宽高
	var w = span.offsetWidth;
	var h = span.offsetHeight;
	//设置为目标字体,如无则默认字体
	span.style.fontFamily = font + ',' + word;
	//判断目标字体是否与宋体一致
	var differ =((span.offsetWidth != w) || (span.offsetHeight != h));
	    
	body.removeChild(span);
	return differ? true : false;
}


